// /**
//  * @param {number[][]} mat
//  * @return {number[][]}
//  */
//  var updateMatrix = function(mat) {

//     // f[m][n]标识当前点距离最近0的距离
//     let rol = mat.length
//     let col = mat[0].length
//     let f = []
//     for(let i = 0; i < rol; i++ ){
//         f[i] = new Array(col).fill(100)
//     }
//     // 转移方程
//     // f[m][n] = f[m][n] ? minDistancec(f[m -1][n],f[m + 1][n],f[m][n + 1],f[m][n - 1]) : 0
//     // 这里遍历到m,n的时候它的左边节点和上面的f都已经求出来了，下面的还没有求出来
//     //注意边界的处理
//     debugger
//     let max = 100
//     for(let i = 0; i < rol; i++){
//         for(let j = 0; j < col; j++){
           
//             if(mat[i][j]){
//                 // 上面节点
//                 let top = i > 0 ? f[i - 1][j] : max
//                 let left = j > 0 ? f[i][j - 1] : max
//                 f[i][j] = Math.min(top+1,left+1)
//             }else{
//                 f[i][j] = mat[i][j]
//             } 
//              // 走到当前的（i,j）节点时，它的右边和下面节点f[i][j+1]和f[i+1][j]
//             // 没有更新出对应的状态的，还是初始的值，这样必须使用一个技巧，
//             //当前值完成计算之后去更新它正上方节点的最终取值，这样就是最终的结果
//             // 如果列不为0就更新前一个节点的值
//             if(j){
//                 //更新左边所有节点的值
//                 let temp = j
//                 while(temp){
//                     f[i][temp - 1] = Math.min(f[i][temp - 1],f[i][temp] + 1)
//                     temp--
//                 }
                
//             }
//             //如果行不为0就更新当前节点的正上方节点的值
//             if(i){
//                 let temp = i
//                 while(temp){
//                     f[temp - 1][j] = Math.min(f[temp - 1][j],f[temp][j] + 1)
//                     temp--
//                 }
//             }
//         }
//     }
//     return f
// };


/**
 * @param {number[]} nums
 * @return {number[][]}
 */
//  var permute = function(nums) {
//     // debugger
//     // 同样是DFS + 剪枝
//     let res = [] // 计算结果
//     let Stack = [] // DFS的路径
//     let len = nums.length
//     // 传入数组和每次选取的数字
//     function DFS(arr){
//         if(Stack.length === len){
//             res.push([...Stack])
//             return
//         }
//         let temp = [...arr] // 复制一个出来不修改原来的数组
//         for(let i = 0; i < temp.length; i++){
//             Stack.push(temp[i])
//             DFS(temp.filter((item,index)=>(index !== i)))
//             Stack.pop()
//         }
//     }
//     DFS(nums)
//     return res
// };
// let nums = [1,2,3]
// let res = permute(nums)
// console.log(res)

/* var rob = function(nums) {
    // f[n] 表示截止到当前房屋，能偷盗的最大金额
    // 转移方程 f[n] = max(a[n] + f[n - 2],f[n - 1])
    debugger
    let f = new Array(nums.length)
    f[0] = nums[0]
    f[1] = nums[0] > nums[1] ? nums[0] : nums[1]
    for(let i = 2; i < nums.length; i++){
        let temp1 = nums[i] + f[i - 2]
        let temp2 = f[i - 1]
        f[i] = Math.max(temp1, temp2)
    }
    return f[nums.length - 1]
};
let arr = [1,2,3,1]
console.log(rob(arr)) */

var integerReplacement = function(n) {
    let time = 0
    // debugger
    while(n !== 1){
        // 奇数的时候使用加一还是减一，主要是让这个变化之后的数/2之后是偶数，这样减小最快
        if(n % 2){
            let temp = n - 1
            if(temp / 2 % 2){
                n = n + 1
            }else{
                n = n - 1
            }
        }else{
            n = Math.floor(n / 2)
        }
        time++
    }
    return time
};
console.log(integerReplacement(31))
